import { http } from "@/utils/http";

// ==================== 类型定义 ====================

/** API响应基础类型 */
export interface ApiResponse<T = any> {
  code: number;
  message: string;
  data: T;
}

/** 分页响应类型 */
export interface PageResult<T> {
  records: T[];
  total: number;
  size: number;
  current: number;
  pages: number;
}

/** 分类状态枚举 */
export enum CategoryStatus {
  /** 禁用 */
  DISABLED = 0,
  /** 启用 */
  ENABLED = 1
}

/** 批量操作类型枚举 */
export enum BatchOperationType {
  /** 启用 */
  ENABLE = "ENABLE",
  /** 禁用 */
  DISABLE = "DISABLE",
  /** 删除 */
  DELETE = "DELETE"
}

/** 分类信息 */
export interface CategoryInfo {
  /** 分类ID */
  id: number;
  /** 分类名称 */
  name: string;
  /** 分类描述 */
  description: string;
  /** 分类图标 */
  icon?: string;
  /** 排序值 */
  sortOrder: number;
  /** 状态 */
  status: number;
  /** 状态文本 */
  statusText?: string;
  /** 文章总数 */
  articleCount?: number;
  /** 已发布文章数 */
  publishedArticleCount?: number;
  /** 草稿文章数 */
  draftArticleCount?: number;
  /** 创建时间 */
  createTime: string;
  /** 更新时间 */
  updateTime: string;
}

/** 分类查询参数 */
export interface CategoryListQuery {
  /** 当前页 */
  current?: number;
  /** 页大小 */
  size?: number;
  /** 分类名称 */
  name?: string;
  /** 状态 */
  status?: number;
  /** 开始时间 */
  startTime?: string;
  /** 结束时间 */
  endTime?: string;
  /** 排序字段 */
  sortField?: string;
  /** 排序方式 */
  sortOrder?: string;
  /** 是否包含文章数量 */
  includeArticleCount?: boolean;
}

/** 创建分类参数 */
export interface CreateCategoryRequest {
  /** 分类名称 */
  name: string;
  /** 分类描述 */
  description: string;
  /** 分类图标 */
  icon?: string;
  /** 排序值 */
  sortOrder: number;
  /** 状态 */
  status: number;
}

/** 更新分类参数 */
export interface UpdateCategoryRequest {
  /** 分类ID */
  id: number;
  /** 分类名称 */
  name: string;
  /** 分类描述 */
  description: string;
  /** 分类图标 */
  icon?: string;
  /** 排序值 */
  sortOrder: number;
  /** 状态 */
  status: number;
}

/** 批量操作参数 */
export interface BatchOperationParams {
  /** 分类ID列表 */
  categoryIds: number[];
  /** 操作类型 */
  operation: string;
  /** 目标状态 */
  targetStatus?: number;
  /** 操作原因 */
  reason?: string;
}

/** 分类统计信息 */
export interface CategoryStatistics {
  /** 总分类数 */
  total_categories: number;
  /** 启用分类数 */
  enabled_categories: number;
  /** 禁用分类数 */
  disabled_categories: number;
  /** 已使用分类数 */
  used_categories: number;
  /** 未使用分类数 */
  unused_categories: number;
}

/** 分类状态分布 */
export interface CategoryStatusDistribution {
  /** 状态 */
  status: number;
  /** 数量 */
  count: number;
  /** 状态名称 */
  status_name: string;
}

/** 分类使用情况统计 */
export interface CategoryUsageStatistics {
  /** 分类ID */
  id: number;
  /** 分类名称 */
  name: string;
  /** 状态 */
  status: number;
  /** 文章总数 */
  total_articles: number;
  /** 已发布文章数 */
  published_articles: number;
  /** 草稿文章数 */
  draft_articles: number;
  /** 最新文章时间 */
  latest_article_time: string;
}

// ==================== API 接口函数 ====================

/** 分页查询分类列表 */
export const getCategoryListApi = (params: CategoryListQuery) => {
  return http.request<ApiResponse<PageResult<CategoryInfo>>>(
    "get",
    "/admin/categories/list",
    { params }
  );
};

/** 获取分类详情 */
export const getCategoryDetailApi = (categoryId: number) => {
  return http.request<ApiResponse<CategoryInfo>>(
    "get",
    `/admin/categories/${categoryId}`
  );
};

/** 获取启用的分类列表 */
export const getEnabledCategoriesApi = () => {
  return http.request<ApiResponse<CategoryInfo[]>>(
    "get",
    "/admin/categories/enabled"
  );
};

/** 创建分类 */
export const createCategoryApi = (data: CreateCategoryRequest) => {
  return http.request<ApiResponse>("post", "/admin/categories/create", {
    data
  });
};

/** 更新分类 */
export const updateCategoryApi = (data: UpdateCategoryRequest) => {
  return http.request<ApiResponse>("put", "/admin/categories/update", { data });
};

/** 删除分类 */
export const deleteCategoryApi = (categoryId: number) => {
  return http.request<ApiResponse>("delete", `/admin/categories/${categoryId}`);
};

/** 启用分类 */
export const enableCategoryApi = (categoryId: number) => {
  return http.request<ApiResponse>(
    "post",
    `/admin/categories/${categoryId}/enable`
  );
};

/** 禁用分类 */
export const disableCategoryApi = (categoryId: number) => {
  return http.request<ApiResponse>(
    "post",
    `/admin/categories/${categoryId}/disable`
  );
};

/** 更新分类排序 */
export const updateCategorySortApi = (
  categoryId: number,
  sortOrder: number
) => {
  return http.request<ApiResponse>(
    "post",
    `/admin/categories/${categoryId}/sort`,
    { params: { sortOrder } }
  );
};

/** 批量操作分类 */
export const batchOperateCategoriesApi = (params: BatchOperationParams) => {
  return http.request<ApiResponse>("post", "/admin/categories/batch", {
    data: params
  });
};

/** 检查分类名称是否可用 */
export const checkCategoryNameApi = (name: string, excludeId?: number) => {
  const params: any = { name };
  if (excludeId) {
    params.excludeId = excludeId;
  }
  return http.request<ApiResponse<boolean>>(
    "get",
    "/admin/categories/check-name",
    { params }
  );
};

/** 获取下一个排序值 */
export const getNextSortOrderApi = () => {
  return http.request<ApiResponse<number>>(
    "get",
    "/admin/categories/next-sort-order"
  );
};

/** 获取分类统计信息 */
export const getCategoryStatisticsApi = () => {
  return http.request<ApiResponse<CategoryStatistics>>(
    "get",
    "/admin/categories/statistics"
  );
};

/** 获取分类状态分布 */
export const getCategoryStatusDistributionApi = () => {
  return http.request<ApiResponse<CategoryStatusDistribution[]>>(
    "get",
    "/admin/categories/status-distribution"
  );
};

/** 获取分类使用情况统计 */
export const getCategoryUsageStatisticsApi = () => {
  return http.request<ApiResponse<CategoryUsageStatistics[]>>(
    "get",
    "/admin/categories/usage-statistics"
  );
};

// ==================== 工具类 ====================

export class CategoryManagementUtils {
  /** 获取分类状态文本 */
  static getStatusText(status: number): string {
    const statusMap: Record<number, string> = {
      0: "禁用",
      1: "启用"
    };
    return statusMap[status] || "未知状态";
  }

  /** 获取状态标签类型 */
  static getStatusTagType(
    status: number
  ): "success" | "info" | "warning" | "danger" | "primary" {
    const typeMap: Record<
      number,
      "success" | "info" | "warning" | "danger" | "primary"
    > = {
      0: "danger",
      1: "success"
    };
    return typeMap[status] || "info";
  }

  /** 获取批量操作类型文本 */
  static getBatchOperationText(type: string): string {
    const textMap: Record<string, string> = {
      ENABLE: "启用",
      DISABLE: "禁用",
      DELETE: "删除"
    };
    return textMap[type] || "未知操作";
  }

  /** 检查是否可以执行操作 */
  static canPerformOperation(status: number, operation: string): boolean {
    const operationMap: Record<number, string[]> = {
      0: ["ENABLE", "DELETE"], // 禁用的分类可以启用和删除
      1: ["DISABLE", "DELETE"] // 启用的分类可以禁用和删除
    };

    return operationMap[status]?.includes(operation) || false;
  }

  /** 格式化文章数量显示 */
  static formatArticleCount(count: number): string {
    if (count === 0) return "0";
    if (count < 1000) return count.toString();
    if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
    return `${(count / 10000).toFixed(1)}w`;
  }

  /** 验证分类名称 */
  static validateCategoryName(name: string): {
    valid: boolean;
    message?: string;
  } {
    if (!name || name.trim().length === 0) {
      return { valid: false, message: "分类名称不能为空" };
    }

    if (name.length > 50) {
      return { valid: false, message: "分类名称不能超过50个字符" };
    }

    // 检查特殊字符
    const invalidChars = /[<>'"&]/;
    if (invalidChars.test(name)) {
      return { valid: false, message: "分类名称不能包含特殊字符" };
    }

    return { valid: true };
  }

  /** 验证排序值 */
  static validateSortOrder(sortOrder: number): {
    valid: boolean;
    message?: string;
  } {
    if (sortOrder < 0 || sortOrder > 9999) {
      return { valid: false, message: "排序值必须在0-9999之间" };
    }

    return { valid: true };
  }

  /** 转换布尔值 */
  static toBool(value: any): boolean {
    if (typeof value === "boolean") return value;
    if (typeof value === "number") return value === 1;
    if (typeof value === "string")
      return value === "1" || value.toLowerCase() === "true";
    return false;
  }

  /** 生成分类图标URL */
  static generateIconUrl(iconPath?: string): string {
    if (!iconPath) {
      // 返回内联SVG避免网络请求失败
      return (
        "data:image/svg+xml;base64," +
        btoa(`
        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="#909399" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
          <path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
        </svg>
      `)
      );
    }
    if (iconPath.startsWith("http") || iconPath.startsWith("data:"))
      return iconPath;
    return iconPath.startsWith("/") ? iconPath : `/${iconPath}`;
  }

  /** 计算分类使用率 */
  static calculateUsageRate(usedCount: number, totalCount: number): number {
    if (totalCount === 0) return 0;
    return Math.round((usedCount / totalCount) * 100);
  }
}
